"""
备份配置协调模块

负责协调配置加载器和验证器的联动，不直接读取文件。
"""

import logging
from pathlib import Path
from typing import List, Dict, Any, Optional

from .loader import ConfigLoader, create_config_loader
from .validator import ConfigValidator, create_config_validator


class BackupConfigLoader:
    """备份配置协调器
    
    负责协调配置加载器和验证器的联动，不直接读取文件。
    """
    
    def __init__(self, config_dir: str = "configs"):
        """初始化备份配置协调器
        
        参数:
            config_dir (str): 配置文件目录路径
                示例值: "configs"
        """
        self.config_dir = Path(config_dir)
        self.logger = self._setup_logging()
        self.loader = create_config_loader(config_dir)
        self.validator = create_config_validator(self.logger)
    
    def _setup_logging(self) -> logging.Logger:
        """设置日志记录器
        
        返回:
            logging.Logger: 配置好的日志记录器
        """
        logger = logging.getLogger("database_backup.backup_config")
        if not logger.handlers:
            handler = logging.StreamHandler()
            formatter = logging.Formatter(
                '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
            )
            handler.setFormatter(formatter)
            logger.addHandler(handler)
            logger.setLevel(logging.INFO)
        return logger
    
    def load_all_configs(self, use_cache: bool = True) -> List[Dict[str, Any]]:
        """协调加载和验证所有配置文件
        
        参数:
            use_cache (bool): 是否使用缓存
        
        返回:
            List[Dict[str, Any]]: 验证通过的配置列表
        """
        # 协调加载器加载配置
        raw_configs = self.loader.load_all_configs(use_cache)
        
        # 协调验证器验证配置
        valid_configs = []
        for config in raw_configs:
            try:
                if self.validator.validate_config(config):
                    valid_configs.append(config)
                    self.logger.info(f"协调成功: 配置文件 {config.get('_config_name', 'unknown')} 验证通过")
                else:
                    self.logger.error(f"协调失败: 配置文件 {config.get('_config_name', 'unknown')} 验证失败")
            except Exception as e:
                self.logger.error(f"协调异常: 配置文件 {config.get('_config_name', 'unknown')} 验证过程出错: {e}")
        
        return valid_configs
    
    def load_all_configs_with_status(self) -> Dict[str, List[Dict[str, Any]]]:
        """加载所有配置文件并返回状态信息
        
        返回:
            Dict[str, List[Dict[str, Any]]]: 包含成功和失败配置的字典
        """
        success_configs = []
        failed_configs = []
        
        if not self.config_dir.exists():
            self.logger.error(f"配置目录不存在: {self.config_dir}")
            return {'success': success_configs, 'failed': failed_configs}
        
        # 查找所有.toml配置文件
        config_files = list(self.config_dir.glob('*.toml'))
        
        if not config_files:
            self.logger.warning(f"在目录 {self.config_dir} 中未找到任何配置文件")
            return {'success': success_configs, 'failed': failed_configs}
        
        self.logger.info(f"找到 {len(config_files)} 个配置文件")
        
        for config_file in config_files:
            try:
                config = self._load_single_config(config_file)
                if config:
                    success_configs.append(config)
                    self.logger.info(f"成功加载配置文件: {config_file.name}")
                else:
                    failed_configs.append({
                        '_config_file': str(config_file),
                        'error': '配置加载失败'
                    })
            except Exception as e:
                failed_configs.append({
                    '_config_file': str(config_file),
                    'error': str(e)
                })
                self.logger.error(f"加载配置文件失败 {config_file}: {e}")
        
        return {
            'success': success_configs,
            'failed': failed_configs
        }
    
    def load_single_config(self, config_file: str, use_cache: bool = True) -> Optional[Dict[str, Any]]:
        """协调加载和验证单个配置文件
        
        参数:
            config_file (str): 配置文件路径
            use_cache (bool): 是否使用缓存
        
        返回:
            Optional[Dict[str, Any]]: 验证通过的配置信息，如果失败返回None
        """
        # 协调加载器加载配置
        raw_config = self.loader.load_single_config(config_file, use_cache)
        
        if raw_config is None:
            self.logger.error(f"协调失败: 加载器无法加载配置文件 {config_file}")
            return None
        
        # 协调验证器验证配置
        try:
            if self.validator.validate_config(raw_config):
                self.logger.info(f"协调成功: 配置文件 {config_file} 验证通过")
                return raw_config
            else:
                self.logger.error(f"协调失败: 配置文件 {config_file} 验证失败")
                return None
        except Exception as e:
            self.logger.error(f"协调异常: 配置文件 {config_file} 验证过程出错: {e}")
            return None
    

    
    def validate_config_file(self, config_file: Path) -> tuple[bool, list[str]]:
        """协调验证配置文件
        
        参数:
            config_file (Path): 配置文件路径
        
        返回:
            tuple[bool, list[str]]: (是否有效, 错误信息列表)
        """
        try:
            # 协调加载器加载配置
            config = self.load_single_config(str(config_file), use_cache=False)
            if config is None:
                return False, ["协调失败: 加载器无法加载配置文件"]
            
            # 协调验证器验证配置
            errors = []
            is_valid = self.validator.validate_config(config, errors)
            
            if is_valid:
                self.logger.info(f"协调成功: 配置文件 {config_file} 验证通过")
            else:
                self.logger.error(f"协调失败: 配置文件 {config_file} 验证失败")
            
            return is_valid, errors
            
        except Exception as e:
            self.logger.error(f"协调异常: 配置文件 {config_file} 验证过程出错: {e}")
            return False, [f"协调异常: 验证过程出错: {e}"]
    
    def get_config_dir(self) -> str:
        """获取配置目录路径
        
        返回:
            str: 配置目录路径
        """
        return str(self.config_dir)